home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Source Code / Libraries / DCLAP 4j / DClap / DApplication.cpp < prev    next >
Encoding:
Text File  |  1995-12-17  |  26.6 KB  |  1,138 lines  |  [TEXT/R*ch]
  1. // DApplication.cp
  2.  
  3.  
  4. #include "DClap.h"
  5. #include "DFindDlog.h"
  6.  
  7.  
  8. #if 0
  9. // Skeleton for application is
  10.  
  11. extern "C" Int2 Main (void)
  12. {
  13.   DMyApplication* myapp = new DMyApplication();
  14.   myapp->IApplication("App Name");
  15.   myapp->Run();
  16.   return 0;
  17. }
  18.  
  19. #endif
  20.  
  21.  
  22. DApplication* gApplication = NULL;        // the current application object
  23.  
  24. char* DApplication::kName=  NULL;
  25. char* DApplication::kVersion= NULL;
  26. char* DApplication::kHelpfolder = "Help";
  27.  
  28.  
  29.                     
  30. class DNoteWindow : public DWindow 
  31. {
  32. public:    
  33.     DNoteWindow(const char* message) :
  34.         DWindow( 0, NULL, DWindow::fixed, -5, -5, -50, -20, NULL)
  35.     {    
  36.     DNotePanel* note= new DNotePanel(0, this, message, 0, 0, Nlm_systemFont, justcenter);
  37.     }
  38.  
  39. };
  40.  
  41.  
  42.  
  43.  
  44.  
  45. class DWindowChoiceDialog : public DWindow 
  46. {
  47. public:
  48.     DListBox * fListBox;
  49.     short             fChoice;
  50.     DList      * fList;
  51.     
  52.     DWindowChoiceDialog();
  53.     void Open();
  54.     void OkayAction();
  55.     DWindow* Result();
  56. };
  57.  
  58.  
  59. DWindowChoiceDialog::DWindowChoiceDialog() :
  60.         DWindow( 0, NULL, DWindow::fixed, -10, -10, -50, -20, "Window list", kDontFreeOnClose),
  61.         fChoice(-1),
  62.         fList(NULL),
  63.         fListBox(NULL)
  64. {    
  65.     fList= gWindowManager->GetWindowList();
  66. }
  67.  
  68. void DWindowChoiceDialog::Open()
  69. {
  70.         // NOTE: this window is in window list !!
  71.     DPrompt* pr= new DPrompt(0, this, "Select a window");         
  72.     DListBox* lb= new DListBox(0, this, 20, 5, false);
  73.     fListBox= lb;
  74.     lb->SetResize( DView::relsuper, DView::relsuper);
  75.     lb->StartAppending();
  76.             
  77.     if (fList) {
  78.         char    title[256];
  79.         long i, n= fList->GetSize();
  80.         for (i= n-1; i>=0; i--) {
  81.             DWindow* win= (DWindow*) fList->At(i);
  82.             if (win != this) 
  83.             {
  84.                 win->GetTitle(title,256);
  85.                 lb->Append( title);
  86.                 }
  87.             }
  88.          }
  89.     lb->DoneAppending();
  90.     lb->SetValue(1); // doesn't seem active on DListBox display
  91.     
  92.     this->AddOkayCancelButtons();    
  93.     DWindow::Open();
  94. }
  95.  
  96. void DWindowChoiceDialog::OkayAction() 
  97. { 
  98.     //fChoice= fListBox->GetValue() - 1;  
  99.         //min GetValue==1, win fChoices == 0..GetSize-2, skip topwin = this
  100.     fChoice= (fList->GetSize() - 1) - (fListBox->GetValue() - 1);   
  101. }
  102.     
  103. DWindow* DWindowChoiceDialog::Result() 
  104. { 
  105.     if (fChoice<0) return NULL;
  106.     else return (DWindow*) fList->At(fChoice); 
  107. }
  108.     
  109.  
  110.  
  111.  
  112.  
  113. // CLASS DApplication
  114.  
  115. DApplication::DApplication() :
  116.     DTaskMaster(cAppl)
  117. {
  118.     fDone= false;        
  119.     fAppWindow= NULL;  
  120.     fPathname= NULL;
  121.     fShortname= NULL;
  122.     fAboutLine= NULL;
  123.     fFileSuffix= NULL;
  124.     fAcceptableFileTypes= NULL;
  125.     gApplication= this;
  126.         // default file types
  127.     fFileSuffix = ".txt";
  128.     fAcceptableFileTypes= "TEXT";
  129. }
  130.  
  131.  
  132.  
  133. void DApplication::IApplication(const char* theAppName)
  134. {
  135.     //xdebug("DApplication::IApplication");
  136.     DClapGlobals* initglobals = new DClapGlobals();
  137.     gCursor->watch();  
  138.  
  139.     fPathname = StrDup( gFileManager->GetProgramPath());
  140.     if (theAppName) 
  141.         fShortname= StrDup( theAppName);
  142.     else if (kName) 
  143.         fShortname= StrDup( kName);
  144.     else {
  145.         fShortname= StrDup( gFileManager->FilenameFromPath(fPathname));   
  146.         char * suf= (char*)gFileManager->FileSuffix(fShortname);
  147.         if (suf) *suf= 0; // we don't want no steenking suffix here
  148.         }
  149.         
  150.     char buf[512];
  151.     sprintf( buf, "About %s...", Shortname()); 
  152.     fAboutLine= StrDup(buf);
  153.  
  154. #ifndef WIN_MAC
  155.     if (!fAppWindow) {
  156.             // Non-Mac apps need an fAppWindow to put any application menus into 
  157.             // eventually want user pref for main wind rect...
  158.         fAppWindow= new DWindow(cAppW, this, DWindow::document, 450, 60, 2, 2, (char*)Shortname());
  159.         gWindowManager->SetAppWindow(fAppWindow);
  160.         //fAppWindow->Open(); //<<bad here -- main event loop
  161.         }
  162. #endif
  163.     
  164.     if (!gIconList) gIconList = new DIconList(); //<< do in DIconList.cpp as global init.
  165.   gIconList->ReadAppIcons();
  166.  
  167.     this->InitSpecialEvents();
  168.     this->InstallDefaultPrefs(); // do before calling any GetPref, after ShortName set
  169.     DFindDialog::InitFindDialog();
  170.     
  171.         // read some user prefs
  172.     gTextFontName= this->GetPref( "gTextFontName", "fonts", gTextFontName);
  173.     gTextFontSize= this->GetPrefVal( "gTextFontSize", "fonts", "12");
  174.     gTextTabStops= this->GetPrefVal( "gTextTabStops", "fonts", "4");
  175.     gTextFont         = Nlm_GetFont( gTextFontName, gTextFontSize, false, false, false, NULL);
  176.     if (!gTextFont) gTextFont= Nlm_programFont;
  177.  
  178.     DCluster::SetFont(Nlm_programFont);  
  179.  
  180.     this->SetUpMenus();
  181.     this->UpdateMenus(); // !! need to have this called in task loop somewhere !!
  182. } 
  183.  
  184.  
  185. DApplication::~DApplication()
  186. {
  187.     if (gIconList) gIconList->suicide();
  188.     if (fAboutLine) MemFree( fAboutLine);
  189.     if (fShortname) MemFree( fShortname);
  190.     if (fPathname) MemFree( fPathname);
  191.     gApplication= NULL;
  192. }  
  193.  
  194.  
  195.  
  196. const char*    DApplication::Pathname(void)
  197. {
  198.     return    fPathname;
  199. }
  200.  
  201. const char*    DApplication::Shortname(void)
  202. {
  203.     static char buf[256];
  204.     StrNCpy(buf, fShortname, 256); // having problems w/ someone mangling this string !
  205.     return buf;
  206. }
  207.  
  208.  
  209.  
  210.  
  211. #ifdef WIN_MAC
  212. #ifndef __APPLEEVENTS__
  213.     // undef some conflicts b/n Types.h && NlmTypes
  214. #undef Handle
  215. #undef true
  216. #undef false
  217. //#undef Boolean
  218. #include <AppleEvents.h>
  219. //#define Boolean  Nlm_Boolean
  220. #endif
  221.  
  222. // ??!? 68k mac calls to here now fail --  
  223. // !! REQUIRES 'pascal' function call settings for Mac68K callbacks !
  224.  
  225. #define CALLBACKFORM pascal
  226. //#define CALLBACKFORM extern "C"
  227. //#define CALLBACKFORM static
  228.  
  229. #endif
  230.  
  231. #ifdef WIN_MOTIF
  232. #include <signal.h>
  233. #if defined(OS_UNIX_SUN) || defined(OS_UNIX_IRIX)
  234. #include <sys/wait.h>
  235. #else
  236. #include <wait.h>
  237. #endif
  238. #endif
  239.  
  240.  
  241. // === AppleEvent Numbers ===
  242.  
  243. enum {
  244.                                         // Required Suite
  245. ae_OpenApp            = 1001,
  246. ae_OpenDoc            = 1002,
  247. ae_PrintDoc            = 1003,
  248. ae_Quit                = 1004,
  249.  
  250.                                         // Core Suite
  251. ae_Clone            = 2001,
  252. ae_Close            = 2002,
  253. ae_CountElements    = 2003,
  254. ae_CreateElement    = 2004,
  255. ae_Delete            = 2005,
  256. ae_DoObjectsExist    = 2006,
  257. ae_GetClassInfo        = 2007,
  258. ae_GetData            = 2008,
  259. ae_GetDataSize        = 2009,
  260. ae_GetEventInfo        = 2010,
  261. ae_Move                = 2011,
  262. ae_Open                = 1002,        // Same as ae_OpenDoc
  263. ae_Print            = 1003,        // Same as ae_PrintDoc
  264. ae_Save                = 2012,
  265. ae_SetData            = 2013,
  266.                                         // Miscellaneous Standards
  267. ae_ApplicationDied    = 3001,
  268. ae_BeginTransaction    = 3002,
  269. ae_Copy                = 3003,
  270. ae_CreatePublisher    = 3004,
  271. ae_Cut                = 3005,
  272. ae_DoScript            = 3006,
  273. ae_EditGraphic        = 3007,
  274. ae_EndTransaction    = 3008,
  275. ae_ImageGraphic        = 3009,
  276. ae_IsUniform        = 3010,
  277. ae_MakeObjVisible    = 3011,
  278. ae_Paste            = 3012,
  279. ae_Redo                = 3013,
  280. ae_Revert            = 3014,
  281. ae_TransactionTerm    = 3015,
  282. ae_Undo                = 3016,
  283. ae_Select            = 3017
  284. };
  285.  
  286.  
  287. //static
  288. /*CALLBACKFORM*/ 
  289. short DApplication::HandleSpecialEvent( long inEvent, long outReply, long inNumber)
  290. {
  291. #ifdef WIN_MAC
  292.     AppleEvent    * inAppleEvent, * outAEReply;
  293.     inAppleEvent= (AppleEvent*) inEvent;
  294.     outAEReply  = (AppleEvent*) outReply;
  295. #endif
  296.     
  297.     switch (inNumber) {
  298.     
  299.         case ae_OpenApp:
  300.             //StartUp();
  301.             break;
  302.             
  303.         case ae_Quit:
  304.             gApplication->Quit();
  305.             break;
  306.  
  307.         case ae_ApplicationDied:
  308.             (void) DChildAppManager::BuryDeadChildApp( inEvent);
  309.             break;
  310.             
  311.         case ae_Copy:
  312.         case ae_Cut:
  313.         case ae_Paste:
  314.         case ae_Redo:
  315.         case ae_Undo:
  316.         case ae_OpenDoc:
  317.         case ae_PrintDoc:
  318.         default:
  319.             //DSomeone::HandleAppleEvent( inAppleEvent, outAEReply, outResult, inNumber);
  320.             break;
  321.         }
  322.  
  323.     return 0;
  324. }
  325.  
  326.  
  327. #ifdef WIN_MAC
  328.  
  329. /*CALLBACKFORM*/
  330. static /* ?? */
  331. short HandleSpecialEvent( long inEvent, long outReply, long inNumber)
  332. {
  333. #ifdef NOTNOW_WIN_MAC
  334.     AppleEvent    * inAppleEvent, * outAEReply;
  335.     inAppleEvent= (AppleEvent*) inEvent;
  336.     outAEReply  = (AppleEvent*) outReply;
  337. #endif
  338.     
  339.     switch (inNumber) {
  340.     
  341.         case ae_ApplicationDied:
  342.             (void) DChildAppManager::BuryDeadChildApp( inEvent);
  343.             break;
  344.             
  345.         case ae_Quit:
  346.             gApplication->Quit();
  347.             break;
  348.  
  349.         case ae_OpenApp:
  350.             //StartUp();
  351.             break;
  352.             
  353.         case ae_Copy:
  354.         case ae_Cut:
  355.         case ae_Paste:
  356.         case ae_Redo:
  357.         case ae_Undo:
  358.         case ae_OpenDoc:
  359.         case ae_PrintDoc:
  360.         default:
  361.             //DSomeone::HandleAppleEvent( inAppleEvent, outAEReply, outResult, inNumber);
  362.             break;
  363.         }
  364.  
  365.     return 0;
  366. }
  367.  
  368. CALLBACKFORM short HandleChildDiedEvent( long inEvent, long outReply, long inNumber)
  369. {
  370.     return ::HandleSpecialEvent( inEvent, outReply, ae_ApplicationDied);
  371. }
  372.  
  373. #endif
  374.  
  375.  
  376. #ifdef WIN_MOTIF
  377. static /*??*/ 
  378. void HandleChildDiedEvent(int signo)
  379. {
  380.     long     pid;
  381.     int        status;
  382.     //pid= wait( &status);
  383.     do {
  384.          pid= waitpid(-1, &status, WNOHANG|WUNTRACED);
  385.          // note: if child exits w/ error, exit(!0), pid == -1 !
  386.         if (pid>0) DApplication::HandleSpecialEvent( pid, 0, ae_ApplicationDied); 
  387.     } while (pid>0);
  388. }
  389. #endif
  390.  
  391.  
  392.  
  393. void DApplication::InitSpecialEvents()
  394. {
  395.     short err;
  396. #ifdef WIN_MAC
  397.  
  398.     // problems w/ "aevt-oapp" call bombing on 68k mac but not ppc mac
  399.     
  400. #define aeproccall(x) NewAEEventHandlerProc(x)
  401. //#define aeproccall(x) ((AEEventHandlerUPP)(x))
  402.  
  403.     err= ::AEInstallEventHandler( kCoreEventClass, kAEOpenApplication,
  404.                                 aeproccall(::HandleSpecialEvent), 
  405.                                 //aeproccall(DApplication::HandleSpecialEvent), 
  406.                                 ae_OpenApp, false);
  407.     err= ::AEInstallEventHandler( kCoreEventClass, kAEQuitApplication, 
  408.                                 aeproccall(::HandleSpecialEvent), 
  409.                                 //aeproccall(DApplication::HandleSpecialEvent), 
  410.                                 ae_Quit, false);
  411.  
  412.     err= ::AEInstallEventHandler( kCoreEventClass, kAEApplicationDied, 
  413.                                 aeproccall(::HandleChildDiedEvent), 
  414.                                 //aeproccall(DApplication::HandleSpecialEvent), 
  415.                                 ae_ApplicationDied, false);
  416.                                 
  417.     err = ::AEInstallEventHandler(kCoreEventClass, kAEOpenDocuments,
  418.                                 aeproccall(::HandleSpecialEvent), 
  419.                                 //aeproccall(DApplication::HandleSpecialEvent), 
  420.                                 ae_Open, false);
  421.     err = ::AEInstallEventHandler(kCoreEventClass, kAEPrintDocuments,
  422.                                 aeproccall(::HandleSpecialEvent), 
  423.                                 //aeproccall(DApplication::HandleSpecialEvent), 
  424.                                 ae_Print, false);
  425.  
  426. #endif
  427.  
  428. #ifdef WIN_MOTIF
  429.     // install signals to trap ?? childDied events at least
  430.     //err= sighold( SIGCHLD);
  431. #ifndef OS_UNIX_IRIX
  432.         // need to figure out IRIX format for this
  433.      signal( SIGCHLD, HandleChildDiedEvent); 
  434. #endif
  435. #endif
  436. }
  437.  
  438.  
  439.  
  440. Boolean DApplication::InstallDefaultPrefs(const char* defaultSuffix, const char* appName)
  441. {
  442.     Boolean didinstall= false;
  443.     char  *cp, defaultPrefs[512];
  444.     
  445.         // locate any program default preference file
  446.     if (!appName) appName= Shortname();
  447. #if 0
  448.     const char* appPath = gFileManager->GetProgramPath();  
  449.     appPath= gFileManager->PathOnlyFromPath( appPath);
  450.     StrNCpy(defaultPrefs, (char*)appPath, 512);
  451.     StrNCat(defaultPrefs, (char*)appName, 512);
  452. #else
  453.     StrNCpy(defaultPrefs, (char*)appName, 512);
  454. #endif
  455.     cp= (char*)gFileManager->FileSuffix(defaultPrefs); if (cp) *cp= 0;
  456.     
  457.     StrNCat(defaultPrefs, (char*)defaultSuffix, 512);
  458.  
  459.     if (gFileManager->FileExists(defaultPrefs)) {
  460.         short     iline, nlines = 0;
  461.         char    **linelist;
  462.         char    * cp, * line = NULL, * section = NULL, * varname = NULL, * params = NULL;
  463.         long         curver= 0, defver= 0;
  464.          
  465.         curver= this->GetPrefVal("version","general",NULL);
  466.         linelist= gPrefManager->GetPrefFileLines( defaultPrefs, nlines);
  467.  
  468.             // 1st check quickly if defaultPrefs has anything newer than user prefs
  469.             // if not, exit silently, else put up notice window....
  470.         for (iline= 0; iline<nlines; iline++) {
  471.             line= linelist[iline];
  472.             if (*line == '[') { // sect name 
  473.                 cp= StrStr(line,"[version=");
  474.                 if (cp) defver= atol(cp+9);
  475.                 if (defver > curver) break;
  476.                 }
  477.             }
  478.         if (defver <= curver) return false;    
  479.     
  480.         Nlm_MonitorPtr progress= Nlm_MonitorIntNew("Installing new preferences...", 0, nlines);
  481.                 // ^^^ incorporate Nlm_Monitor into a DCLAP class
  482.         
  483.         gCursor->watch();
  484.         for (iline= 0; iline<nlines; iline++) {
  485.             if (Nlm_MonitorIntValue(progress, iline)) ;
  486.             line= linelist[iline];
  487.             if (line) {
  488.                 if (*line == '[') { // sect name 
  489.                     cp= StrStr(line,"[version=");
  490.                     if (cp)  
  491.                         defver= atol(cp+9);
  492.                     else {
  493.                         if (section) MemFree(section);
  494.                         section= StrDup(line+1);
  495.                         }
  496.                     }
  497.                 else {
  498.                     params= StrChr(line, '=');
  499.                     if (params) *params++= 0;
  500.                     varname= line;
  501.                     if (defver > curver) {
  502.                         this->SetPref( params, varname, section);
  503.                         }
  504.                     }
  505.                 MemFree(line);
  506.                 }
  507.             }
  508.         MemFree(linelist);
  509.         this->SetPref(defver, "version","general");
  510.         didinstall= true;
  511.  
  512.         Nlm_MonitorFree(progress);        
  513.         }
  514.      return didinstall;
  515. }
  516.  
  517.  
  518.  
  519.  
  520. char*    DApplication::GetPref(char* type, char* section, char* defaultvalue)
  521. {
  522.     return gPrefManager->GetAppPref( type, section, (char*)Shortname(), defaultvalue);
  523. }
  524.  
  525. long    DApplication::GetPrefVal(char* type, char* section, char* defaultvalue)
  526. {
  527.     long val= 0;
  528.     char* sval= gPrefManager->GetAppPref( type, section, (char*)Shortname(), defaultvalue);
  529.     if (sval) {
  530.         val= atol(sval);
  531.         MemFree(sval);
  532.         }
  533.     return val;
  534. }
  535.  
  536. char*    DApplication::GetPrefSection(char* section, ulong& sectlen, char* defaultvalue)
  537. {
  538.     return gPrefManager->GetAppPrefSection(section, sectlen, (char*)Shortname(), defaultvalue);
  539. }
  540.  
  541.  
  542. Boolean DApplication::SetPref(char* prefvalue, char* type, char* section)
  543. {
  544.     return gPrefManager->SetAppPref(prefvalue, type, section, (char*)Shortname());
  545. }
  546.  
  547. Boolean DApplication::SetPref(long prefvalue, char* type, char* section)
  548. {
  549.     char    snum[256];
  550.     sprintf(snum, "%d", prefvalue);
  551.     return gPrefManager->SetAppPref(snum, type, section, (char*)Shortname());
  552. }
  553.  
  554. char*    DApplication::ConvertStdFilePath(char* pathname)
  555. {
  556.     char     *path, *name, *newpath;
  557.     
  558.     pathname= StrDup( pathname);
  559.     path= StrChr(pathname, ':');
  560.     if (path) {
  561.         name= path+1;
  562.         *path=0;
  563.         path= this->GetPref( pathname, "paths", NULL);
  564.         if (path) {
  565.             DFileManager::UnixToLocalPath(path);
  566.             newpath= StrDup( DFileManager::BuildPath( path, NULL, name)); 
  567.             MemFree( pathname);
  568.             MemFree( path);
  569.             pathname= newpath;
  570.             }
  571.         else
  572.             ; // return full pathname !?
  573.             // MemMove(pathname, name, StrLen(name)+1);
  574.         }
  575.     return pathname;
  576. }
  577.  
  578. char*    DApplication::GetFilePref(char* type, char* section, char* defaultvalue)
  579. {
  580.     char * pathname, *newpath;
  581.  
  582.     pathname = this->GetPref( type, section, defaultvalue);
  583.     newpath = ConvertStdFilePath( pathname);
  584.     MemFree( pathname);
  585.     return newpath;
  586. }
  587.  
  588.  
  589.  
  590.  
  591.  
  592.  
  593. #ifdef WIN_MOTIF
  594. extern void TaskCentralIdleEvent()
  595. {
  596.     gTaskCentral->NextTask();
  597. }
  598. #endif
  599.  
  600. void    DApplication::Run(void)
  601. {
  602.     if (fAppWindow)  fAppWindow->Open();
  603.     if (gClipboardMgr) gClipboardMgr->Launch();     
  604.  
  605.     gCursor->arrow();  
  606. #ifdef WIN_MOTIF
  607.   Nlm_Metronome( TaskCentralIdleEvent);
  608. #endif
  609.     this->MainEventLoop();
  610.     gCursor->arrow();
  611. }
  612.  
  613. void DApplication::MainEventLoop(void)
  614. {
  615.     while (!fDone) this->ProcessTasks();
  616. }
  617.  
  618. void DApplication::ProcessTasks(void)
  619. {
  620.     Nlm_ProcessEventOrIdle();
  621.     Nlm_RemoveDyingWindows();
  622.     gTaskCentral->NextTask();
  623. }
  624.  
  625. Boolean    DApplication::EventsAvail() 
  626. { 
  627.     return Nlm_EventAvail();
  628. }
  629.  
  630. void    DApplication::FlushEvents() 
  631. { 
  632.     Nlm_FlushEvents();
  633. }
  634.  
  635.  
  636. void DApplication::Quit()
  637. {
  638.     fDone= true;
  639.     if (gWindowManager) delete gWindowManager; gWindowManager= NULL;
  640.     // ?? ^^ is this okay, we got one bomb on a DWindow call after Quit & WinMgr == NULL
  641.     //if (gWindowManager) gWindowManager->suicide();  
  642.   Nlm_QuitProgram (); // this justs sets a local vibrant global, in ProcessEvents(), which we don't see
  643. }
  644.  
  645. void    DApplication::SetAppMenuWindow(DWindow* itsWindow)
  646. {
  647.     fAppWindow= itsWindow;
  648. }
  649.  
  650.  
  651. void    DApplication::OpenDocument(char* pathname)
  652. {
  653.     DFile *afile= new DFile( pathname, "r");
  654.     OpenDocument( afile);
  655.     delete afile; // ???
  656. }
  657.  
  658. void    DApplication::OpenDocument(DFile* aFile)
  659. {
  660.     // default OpenDoc is to use Vibrant's text display
  661.     if (aFile && aFile->Exists()) {
  662.         Nlm_ParData  paratabs = {false, false, false, false, true, 0, 0}; // tabs==tabs
  663.         Nlm_ColData* coldata= NULL;
  664.  
  665.         gCursor->watch();
  666.         aFile->CloseFile(); // ShowFile manages this..
  667.         char* shortname= (char*)aFile->GetShortname();
  668.         DWindow* win= new DWindow(0, this, DWindow::document, -1, -1, -10, -10, shortname);
  669.         DTextDocPanel* td= new DTextDocPanel(0, win, 500, 300);
  670.  
  671.         td->SetSlateBorder( false);
  672.         td->SetResize( DView::matchsuper, DView::relsuper);
  673.         //td->SetTabs( gTextTabStops);
  674.         
  675.         const char* fullname= aFile->GetName();
  676. #if 0
  677.         td->ShowFile( (char*)fullname, gTextFont);
  678. #else
  679.         td->ShowFileFancy( (char*)fullname, ¶tabs, coldata, gTextFont, gTextTabStops);
  680. #endif
  681.         
  682.         win->Open();
  683.         td->SizeToSuperview( win, true, false); // this needs to adjust for if view has scrollbar !
  684.         gCursor->arrow();
  685.         }
  686. }
  687.  
  688.  
  689. Boolean    DApplication::ChooseFile(DFile*& openedFile, char* filesuffix, char* acceptableTypeIDs)
  690. {
  691.     DFile* aFile;
  692.     //if (openedFile) delete openedFile; //??
  693.     openedFile= NULL;
  694.     char* name= (char*) gFileManager->GetInputFileName( filesuffix, acceptableTypeIDs); 
  695.     if (name) {
  696.         aFile= new DFile( name, "r");
  697.         if (aFile->Exists()) {
  698.             openedFile= aFile;
  699.             return true;
  700.             }
  701.         else {
  702.             delete aFile;
  703.             return false;
  704.             }
  705.         }
  706.     else
  707.         return false;
  708. }
  709.  
  710.  
  711.  
  712. Boolean DApplication::DoMenuTask(long tasknum, DTask* theTask)
  713. {
  714.     DWindow* win;
  715.     
  716.     switch (tasknum) {
  717.  
  718.         case DAppleMenu::kAboutMenuItem: 
  719.             // ^^this is likely handled by DAppleMenu object
  720.         case kAbout:
  721.             this->DoAboutBox();
  722.             return true;
  723.  
  724.         case kHelp:
  725.             this->DoHelp();
  726.             return true;
  727.             
  728.         case kNew:
  729.             Message(MSG_OK,"DApplication::New not ready.");
  730.             //this->CreateDocument();
  731.             return true;
  732.             
  733.         case kOpen:
  734.             {
  735.             DFile* aFile = NULL;
  736.             if (this->ChooseFile( aFile, fFileSuffix, fAcceptableFileTypes)) 
  737.                 this->OpenDocument( aFile);
  738.             }
  739.             return true;
  740.             
  741.         case kClose: 
  742.             win= gWindowManager->CurrentWindow();
  743.             if (win) win->CloseAndFree(); // test win for doc needing saving ??
  744.             return true;
  745.                             
  746.         case kSave:
  747.         case kSaveAs:
  748.             win= gWindowManager->CurrentWindow();
  749.             if (win && win->fSaveHandler) {
  750.                 const char* name;
  751.                 char  namestore[256];
  752.                 Boolean changewinname= false;
  753.                 char* defname= win->GetTitle(namestore,sizeof(namestore));
  754.                 if (!defname || !*defname || StrCmp(defname,DFileManager::kUntitled)==0) 
  755.                     tasknum= kSaveAs;  
  756.                 if (tasknum == kSave)
  757.                     name= defname;
  758.                 else {
  759.                     name= gFileManager->GetOutputFileName(defname);
  760.                     changewinname= true;
  761.                     }
  762.                 if (name && *name) {
  763.                     DFile* myFile = new DFile(name, "w");
  764.                     if (myFile) {
  765.                         myFile->OpenFile();
  766.                         win->SaveDoc(myFile); 
  767.                         myFile->CloseFile();
  768.                         delete myFile;
  769.                         if (changewinname) 
  770.                           win->SetTitle((char*)DFileManager::FilenameFromPath(name));
  771.                         }
  772.                     }
  773.                 }
  774.             else 
  775.                 Message(MSG_OK,"DApplication::Save not ready.");
  776.             return true;
  777.  
  778.         case kFindAgain:
  779.             win= gWindowManager->CurrentWindow();
  780.             if (win && win->fFindDlog) 
  781.                 win->fFindDlog->FindAgain(); 
  782.             else
  783.                 Message(MSG_OK,"DApplication::FindAgain not available.");
  784.             return true;
  785.             
  786.         case kFind:
  787.             win= gWindowManager->CurrentWindow();
  788.             if (win && win->fFindDlog) {
  789.                 if ( win->fFindDlog->PoseModally() ) ;
  790.                 }
  791.             else
  792.                 Message(MSG_OK,"DApplication::Find not available.");
  793.             return true;
  794.             
  795.         case kPrint:
  796.             win= gWindowManager->CurrentWindow();
  797.             if (win && win->fPrintHandler) 
  798.                 win->PrintDoc();
  799.             else
  800.                 Message(MSG_OK,"DApplication::Print not ready.");
  801.             return true;
  802.  
  803.         case kQuit:
  804.             this->Quit(); // this should be a task added to end of task queue...??
  805.             return true;
  806.             
  807.         case kPrevWindow:
  808.             gWindowManager->BringToFront();
  809.             return true;
  810.         case kNextWindow:
  811.             gWindowManager->SendToBack();
  812.             return true;
  813.             
  814.         case kChooseWindow:
  815. #ifndef BOBS_WIN_MAC                        
  816.           {
  817.             DWindowChoiceDialog* dlg= new DWindowChoiceDialog();
  818.             if ( dlg->PoseModally() ) {
  819.                 DWindow* win = dlg->Result();
  820.                 if (win && win != dlg) win->Select();
  821.                 }
  822.             delete dlg;
  823.             }
  824. #else
  825. #endif
  826.             return true;
  827.  
  828.         case kUndo:
  829.             if (gLastCommand) gLastCommand->UndoRedo();
  830.             return true;
  831.  
  832.         case kDeleteDeadWindow:
  833.             {
  834.             DView* windowCarcass= (DView*) theTask->fExtra;
  835.             if (windowCarcass) delete windowCarcass;
  836.             }
  837.             return true;
  838.  
  839.         default: 
  840.             return DTaskMaster::DoMenuTask(tasknum, theTask);
  841.         }
  842. }
  843.  
  844.  
  845.  
  846. Boolean DApplication::IsMyAction(DTaskMaster* action)
  847. {
  848.     switch(action->Id()) {
  849.  
  850.         case DAppleMenu::kAboutMenuItem:
  851.         case kAbout:
  852.         case kHelp:
  853.         case kNew:
  854.         case kOpen:
  855.         case kClose:
  856.         case kSaveAs:
  857.         case kSave:
  858.         case kPrint:
  859.         case kQuit:
  860.         case kPrevWindow:
  861.         case kNextWindow:
  862.         case kChooseWindow:
  863.         case kFind:
  864.         case kFindAgain:
  865.         case kUndo:
  866.             return DoMenuTask(action->Id(), NULL);
  867.  
  868.         case kCut:
  869.         case kCopy:
  870.         case kPaste:
  871.         case kClear:
  872.         case kSelectAll:
  873.             {
  874.                     // looks like Vibrant doesn't currently support a system clipboard for
  875.                     // copy/paste of text (& other objects) between applications...
  876.             DWindow* win = gWindowManager->CurrentWindow();
  877.             DDialogText* dtext= gWindowManager->CurrentDialogText();
  878.             if (dtext && win && win->HasEditText()) {
  879.                 if (win != dtext->GetWindow()) dtext = win->fEditText;
  880.                     // ^^ if this is true, we can't tell which of multiple texts may be
  881.                     // the intended target ... CurrentDialogText() is supposed to track user text.
  882.                 if (dtext->IsMyAction(action)) return true;
  883.                 }
  884.             if (win && win->IsMyAction(action)) return true;
  885.             Message(MSG_OK,"Application::Edits not ready.");
  886.             return true;
  887.             }
  888.             
  889.         case kShowClipboard:
  890.             gClipboardMgr->DoMenuTask( action->Id(), NULL);
  891.             return true;
  892.             
  893.         case cOKAY:
  894.         case cCANC:
  895.             {
  896.             DButton* but= (DButton*) action;
  897.             DWindow* win;
  898.             if ( but && ((win= but->GetWindow()) != NULL) ) {
  899.                 if (action->Id() == cOKAY) {
  900.                     // do Okay close handling...
  901.                     }
  902.                 win->CloseAndFree();
  903.                 }
  904.             }
  905.             return true;
  906.  
  907.         default:
  908.             return DTaskMaster::IsMyAction(action);
  909.         }
  910. }
  911.  
  912. DMenu* DApplication::NewMenu(long id, char* title)
  913. {
  914.     Nlm_WindoW nwind = (fAppWindow) ? (Nlm_WindoW)fAppWindow->GetNlmObject() : NULL;
  915.     return new DPulldownMenu( id, this, nwind, title);
  916. }
  917.  
  918.  
  919.  
  920. void    DApplication::SetUpMenus(void)
  921. {
  922.     DMenu* aMenu = NULL;
  923.     this->SetUpMenu(cFileMenu, aMenu);
  924.     aMenu= NULL;
  925.     this->SetUpMenu(cEditMenu, aMenu);
  926.     aMenu= NULL;
  927.     this->SetUpMenu(cWindowMenu, aMenu);
  928. }
  929.  
  930. void DApplication::SetUpMenu(short menuId, DMenu*& aMenu) 
  931. {
  932.     // ?? either change menu objects to local/nonpointer, 
  933.     // or suicide() them to remove all but DViewCentral owner
  934.     
  935.     if (menuId == cFileMenu) {
  936. #ifdef WIN_MAC
  937.         DAppleMenu* appleMenu = new DAppleMenu(this,fAboutLine);
  938. #endif
  939.         if (!aMenu) aMenu = this->NewMenu( cFileMenu, "File");
  940. #ifndef WIN_MAC
  941.         aMenu->AddItem(kAbout, fAboutLine);
  942.         aMenu->AddSeparator();
  943. #endif
  944.         aMenu->AddItem(kNew,"New/N",false, true);
  945.         aMenu->AddItem(kOpen,"Open/O",false, true);
  946.         aMenu->AddSeparator();
  947.         aMenu->AddItem(kClose,"Close/W",false, true);
  948.         aMenu->AddItem(kSave,"Save/S",false, true);
  949.         aMenu->AddItem(kSaveAs,"Save As...",false, true);
  950.         aMenu->AddSeparator();
  951.         aMenu->AddItem(kPrint,"Print",false, true);
  952.         aMenu->AddItem(kHelp,"Help/H",false, true);
  953.         aMenu->AddSeparator();
  954.         aMenu->AddItem(kQuit,"Quit/Q",false, true);
  955.         }
  956.     
  957.     else if (menuId == cEditMenu) {
  958.         if (!aMenu) aMenu = this->NewMenu(cEditMenu, "Edit");
  959.         aMenu->AddItem(kUndo,"Undo/Z",false, true);
  960.         gViewCentral->DisableView(kUndo);  // don't know undo yet... :-(ouch)
  961.         aMenu->AddSeparator();
  962.         aMenu->AddItem(kCut,"Cut/X",false, true);
  963.         aMenu->AddItem(kCopy,"Copy/C",false, true);
  964.         aMenu->AddItem(kPaste,"Paste/V",false, true);
  965.         aMenu->AddItem(kClear,"Clear",false, true);
  966.         aMenu->AddItem(kSelectAll,"Select All/A",false, true);    
  967.         aMenu->AddItem(kShowClipboard,"Show clipboard",false, true);
  968.         gViewCentral->DisableView(DApplication::kShowClipboard);
  969.         }
  970.         
  971.     else if (menuId == cWindowMenu) {
  972.         if (!aMenu) aMenu= this->NewMenu(cWindowMenu, "Windows");
  973.         aMenu->AddItem(kPrevWindow,"Prev/-",false, true); // == bring last win to front
  974.         aMenu->AddItem(kNextWindow,"Next/+",false, true); // == send top win to last
  975.         aMenu->AddItem(kChooseWindow,"Select...");  
  976.         //aMenu->AddSeparator();
  977.         //this->AddWindowListToMenu(menuId, aMenu); //gWindowManager->GetWindowList();
  978.         }
  979.  
  980. }
  981.  
  982.  
  983.  
  984. #if NOT_READY
  985.     
  986. void DApplication::SetWindowMenu(Boolean activate)
  987. {                  
  988. #ifndef BOBS_WIN_MAC                        
  989.                         // THIS IS NO GOOD ON XWIN, and on MSWIN
  990.                         // Vibrant currently has no way of removing single menu items
  991.                         // except for Mac.  Only option for others seems to be removal
  992.                         // of entire (sub) menu, with no way to replace w/ a new menu
  993.                         // in *same* position !!!
  994. #else                        
  995.    if (fWindowChoiceMenu) {
  996.          short item= kViewDefault;
  997.          fWindowChoiceMenu->Reset();  
  998.          fWindowChoiceMenu->AddItem( item, "default");
  999.          DList* wins= gWindowManager->GetWindowList();
  1000.          if (activate && wins) {
  1001.             long i, n= wins->GetSize();
  1002.             for (i= 0; i<n; i++) {
  1003.                 char *cp, title[256];
  1004.                 item++;
  1005.                 DWindow* win= (DWindow*) fList->At(i);
  1006.                 win->GetTitle(title,256);
  1007.                 cp= title; 
  1008.                 //while (cp= strchr(cp, '/')) *cp= '_';
  1009.                 fViewChoiceMenu->AddItem( item, smenu);
  1010.                 }
  1011.              }
  1012.      }
  1013. #endif
  1014. }
  1015.  
  1016. #endif
  1017.  
  1018.  
  1019.  
  1020.      
  1021. void DApplication::DoHelp()
  1022. {
  1023.     char filename[512];
  1024.     DFile* afile = new DFile();
  1025.     char* suf;
  1026.     
  1027.     char* apppath = (char*) gFileManager->GetProgramPath();  
  1028.     apppath= (char*) gFileManager->PathOnlyFromPath( apppath);
  1029.     apppath= (char*)gFileManager->BuildPath( apppath, kHelpfolder, (char*)Shortname());
  1030.     afile->Initialize(apppath,"r");
  1031.     if (!afile->Exists()) {
  1032.         StrNCpy(filename, (char*)Shortname(),490);
  1033.         StrCat(filename,".help");
  1034.         afile->Initialize(filename,"r");
  1035.         if (!afile->Exists()) {
  1036.             StrNCpy(filename, (char*)Pathname(),490);
  1037.             suf= (char*)gFileManager->FileSuffix(filename); if (suf) *suf= 0;
  1038.             StrCat(filename,".help");
  1039.             afile->Initialize(filename,"r");
  1040.             }
  1041.         }
  1042.     OpenHelp( afile);
  1043.     delete afile;
  1044. }
  1045.  
  1046.  
  1047.  
  1048. void DApplication::OpenHelp(const char* helpname)
  1049. {
  1050.     char* apppath = (char*) gFileManager->GetProgramPath();  
  1051.     apppath= (char*) gFileManager->PathOnlyFromPath( apppath);
  1052.     const char*    pathname= gFileManager->BuildPath( apppath, kHelpfolder, helpname);
  1053.     DFile* afile = new DFile(pathname,"r");
  1054.     OpenHelp(afile);
  1055.     delete afile;
  1056. }
  1057.  
  1058.  
  1059. void DApplication::OpenHelp(DFile* aFile)
  1060. {
  1061. #if 1
  1062.     if (!aFile || !aFile->Exists()) {
  1063.         const char * name;
  1064.         if (aFile) name= aFile->GetName(); else name= "noname";
  1065.         Message(MSG_OK,"Can't find help file '%s'",name);
  1066.         return;
  1067.         }
  1068.     this->OpenDocument( aFile); 
  1069. #else
  1070.     Nlm_ParData  paratabs = {false, false, false, false, true, 0, 0}; // tabs==tabs
  1071.     Nlm_ColData* coldata= NULL;
  1072.         
  1073.     if (!aFile->Exists()) {
  1074.         Message(MSG_OK,"Can't find help file '%s'",aFile->GetName());
  1075.         return;
  1076.         }
  1077.         
  1078.     gCursor->watch();
  1079.     aFile->CloseFile(); // make sure closed so ShowFile can open !?
  1080.     DWindow* win= new DWindow(cHelp, this, DWindow::document, -1, -1, -10, -10, 
  1081.                                         (char*) aFile->GetShortname());
  1082.     DTextDocPanel* td= new DTextDocPanel(0, win, 490, 300);
  1083.     td->SetSlateBorder( false);
  1084.     td->SetResize( DView::matchsuper, DView::relsuper);
  1085. #if 0
  1086.     td->ShowFile( (char*)aFile->GetName(), gTextFont);
  1087. #else
  1088.     td->ShowFileFancy( (char*)aFile->GetName(), ¶tabs, coldata, gTextFont, gTextTabStops);
  1089. #endif
  1090.     win->Open();
  1091.     td->SizeToSuperview( win, true, false);  
  1092.     gCursor->arrow();
  1093. #endif
  1094. }
  1095.  
  1096.  
  1097. void DApplication::DoAboutBox(void)
  1098. {
  1099.     DAboutBoxWindow* about = new DAboutBoxWindow; // make instance & it handles rest
  1100. }
  1101.  
  1102.     
  1103.  
  1104.  
  1105. void DApplication::UpdateMenus( void)
  1106. {
  1107.         // Is the frontmost window modal?
  1108.     
  1109.     gViewCentral->EnableView(DApplication::kQuit);
  1110.  
  1111.     //if (gInBackground) 
  1112.     {
  1113.         gViewCentral->EnableView(DApplication::kClose);
  1114.         //gViewCentral->EnableView(DApplication::kUndo);
  1115.         gViewCentral->EnableView(DApplication::kCut);
  1116.         gViewCentral->EnableView(DApplication::kCopy);
  1117.         gViewCentral->EnableView(DApplication::kPaste);
  1118.         gViewCentral->EnableView(DApplication::kClear);
  1119.     } 
  1120.  
  1121.     //if (!isModalWindow) 
  1122.     {
  1123.         gViewCentral->EnableView(DApplication::kNew);
  1124.         gViewCentral->EnableView(DApplication::kOpen);
  1125.     }
  1126.  
  1127.     gViewCentral->EnableView(DApplication::kPrevWindow);
  1128.     gViewCentral->EnableView(DApplication::kNextWindow);
  1129.     
  1130.     //Str63    undoStr;
  1131.     //GetIndString(undoStr, STRcommon, strUNDO);
  1132.     //gViewCentral->SetMenuText( DApplication::kUndo, undoStr);
  1133. }
  1134.  
  1135.  
  1136.  
  1137.  
  1138.